The use of JavaScript (trademark of Sun MicroSystems) and AJAX (Asynchronous JavaScript and XML) techniques to build rich internet (global computer network) applications is rapidly growing in popularity but is also growing in complexity. Briefly, JavaScript is an object-oriented scripting language used to enable programmatic access to objects within applications (both server-side applications and client side applications such as Web Browsers and others). A common use of JavaScript is in the form of client-side JavaScript, implemented as an integrated component of the web browser, allowing the development of enhanced user interfaces and dynamic websites. JavaScript is a dialect of the ECMAScript standard and is characterized in the art as a dynamic, weakly typed, prototype-based language with first-class functions.
Generally, client-side JavaScript is used to write functions that (i) are embedded in or included from an HTML page/web page served from a Web Server to a Web Browser, and (ii) interact with the Document Object Model (DOM) of the page. Some simple examples of this usage are:
opening or popping up a new window with programmatic control over the size, position, and other attributes of the new window (i.e. whether the menus, toolbars, etc. are visible);
validating web form input values to make sure that the values will be accepted before they are submitted to the server; and
changing images, such as important links displayed as graphical elements, as the cursor moves over them.
Because JavaScript code can run locally in a client's/user's browser (rather than on a remote server), it can respond to user actions quickly. This in turn produces the effect of making an application feel more responsive. Furthermore, JavaScript code can detect user actions which HTML alone cannot, such as individual keystrokes. Various internet/global computer network applications take advantage of this by having much of the user-interface logic written in JavaScript, and by having JavaScript dispatch requests for information to the server. The wider trend of Ajax programming similarly exploits this strength.
So called “Ajax programming” or AJAX is a group of web development techniques used on the client-side to create interactive web applications. AJAX enables web applications to retrieve data from the server asynchronously in the background without interfering with the display and behavior of the existing Web page. The use of AJAX techniques has led to an increase in interactive or dynamic interfaces on web pages and in some cases better quality of Web services due to the asynchronous mode. Data is usually retrieved using the XMLHttpRequest object. Despite the name, the use of JavaScript and XML together is not actually required, nor do the requests need to be asynchronous.
Initially, the target audience of Java Script was web authors and other such “amateur” programmers. With the advent of AJAX, JavaScript has become one of the most popular programming languages on the web even among professional programmers. The result has been a proliferation of comprehensive frameworks and libraries, improved JavaScript programming practices, and increased usage of JavaScript outside of the browser, as seen by the proliferation of server-side JavaScript platforms. In turn, there is an increasing demand for Java Script debugging and debugger features.
Most web browsers provide some form of JavaScript console and/or ‘DOM inspector’ to view the DOM (Document Object Model) elements on a web page, CSS (Cascade Style Sheets) rules, and JavaScript objects as well as some form of debugger to aid in stepping through JavaScript code. Due to the mostly anonymous nature of JavaScript objects, it is often difficult to visualize the relationships between objects at runtime.
For example, given a single level of inheritance:                function Node(name) {this.name=name;}        ProxyNode.prototype.superclass=Node;        function ProxyNode(name, type) {this.superclass(name); this.type=type;}        function processNode(node) {//do something with ‘node’}Assuming one creates either a Node or ProxyNode and passes it to the processNode function, the best the JS debugger can do is show that the type of the ‘node’ parameter is Object. It will show the member variables as well but one can only tell that the actual type of the object was Node or ProxyNode by looking at the code and seeing that the object one is examining in the debugger has a ‘type’ member so therefore must be a ProxyNode. It is not obvious that ProxyNode inherits from Node in this and other examples.        